home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 298_01 / movebox.c < prev    next >
C/C++ Source or Header  |  1987-11-07  |  6KB  |  277 lines
  1. /* movebox - use cursor keys to move box around screen */
  2. #include <curses.h>
  3.  
  4. #define HELPMSG "<Enter> turns bounce on.  Hit F1 for more help."
  5. #define HELPFILE "movebox.hlp"
  6.  
  7. #define FIRST_X 5
  8. #define FIRST_Y 5
  9. #define W_LINES 5
  10. #define W_COLS 12
  11.  
  12. int scrtype = T_DIRECT;
  13. /* the popup window (box) and its shadow */
  14. WINDOW *small, *shadow;
  15. /* current position of the popup */
  16. int y, x;
  17.  
  18. main()
  19. {
  20.  int i;
  21.  int ch;
  22.  
  23.     initscr();
  24.     pc_uptype(scrtype);
  25.     keypad(stdscr,TRUE);
  26.     
  27.     message(HELPMSG);
  28.     /* fill up the main window */
  29.     for( y = 1; y < LINES; y++ )
  30.         for( x = 0; x < COLS; x++ )
  31.             mvaddch(y, x, ' ' + x);
  32.  
  33.     wnoutrefresh(stdscr);
  34.     
  35.     /* create a small pop-up window to move around */
  36.     y = FIRST_Y;
  37.     x = FIRST_X;
  38.     small = newwin(W_LINES, W_COLS, y, x);
  39.     /* set the window to inverse video */
  40.     wattrset(small, A_REVERSE);
  41.     /* make the whole box inverse video */
  42.     wclear(small);
  43.     /* add text to window */
  44.     mvwaddstr(small, 1, 1, "PC Curses");
  45.     mvwaddstr(small, 2, 2,  "Movebox");
  46.     mvwaddstr(small, 3, 3,   "Demo");
  47.     /* turn off cursor */
  48.     leaveok(small, TRUE);
  49.     /* box it, with the box also in inverse video */
  50.     box(small, A_REVERSE | D_VERT, A_REVERSE | D_HOR);
  51.     shadow = shadowwin(small, NULL);
  52.  
  53.     /* main command loop -- move the small window around the large */
  54.     for(;;) {
  55.         /* popup the small window */
  56.         shadowwin(small, shadow);
  57.         touchwin(small);
  58.         wrefresh(small);
  59.  
  60.         /* get command from user */
  61.         ch = getch();
  62.         /* clear away the small window */
  63.         wnoutrefresh(shadow);
  64.         switch(ch) {
  65.             case KEY_RIGHT:
  66.                 if( OK == mvwin(small, y, x+1) ) x++;
  67.                 break;
  68.             case KEY_LEFT:
  69.                 if( OK == mvwin(small, y, x-1) ) x--;
  70.                 break;
  71.             case KEY_UP:
  72.                 if( OK == mvwin(small, y-1, x) ) y--;
  73.                 break;
  74.             case KEY_DOWN:
  75.                 if( OK == mvwin(small, y+1, x) ) y++;
  76.                 break;
  77.             case '\r':
  78.             case '\n':
  79.                 bounce();
  80.                 message(HELPMSG);
  81.                 break;
  82.             case KEY_F(1):
  83.                 if( ERR == help(HELPFILE) )
  84.                     message("Error setting up help window");
  85.                 break;
  86.             case KEY_F(2):
  87.                 if( scrtype == T_DIRECT ) {
  88.                     scrtype = T_BIOS;
  89.                     message("Now using BIOS updating");
  90.                 }
  91.                 else {
  92.                     scrtype = T_DIRECT;
  93.                     message("Now using DIRECT updating");
  94.                 }
  95.                 pc_uptype(scrtype);
  96.                 break;
  97.             default:
  98.                 endwin();
  99.                 exit(0);
  100.             }
  101.     }
  102. }
  103.  
  104. fatal(str)
  105.  char *str;
  106. {
  107.     puts(str);
  108.     endwin();
  109.     exit(1);
  110. }
  111.  
  112. /* bounce - make the small window bounce, vaguely like pong */
  113. bounce()
  114. {
  115.  int yi = 1, xi = 1;
  116.  int ch;
  117.  static int randomize = 0;
  118.  
  119.     message("Hit any key to stop bouncing");
  120.     for( ; !kbhit(); ) {
  121.         /* try continue moving in same direction */
  122.         if( OK == mvwin(small, y+yi, x+xi) ) {
  123.             y += yi;
  124.             x += xi;
  125.         }
  126.         /* time to change direction */
  127.         else {
  128.             if( ERR == mvwin(small, y+yi, x) ) {
  129.                 yi = -yi;
  130.                 if( randomize ) {
  131.                     if( rand() & 1 ) 
  132.                         if( yi % 2 ) yi = yi % 2;
  133.                         else yi = 1;
  134.                     else yi = yi * 2;
  135.                 }
  136.             }
  137.             else {
  138.                 xi = -xi;
  139.                 if( randomize ) {
  140.                     if( rand() & 1 ) 
  141.                         if( xi % 2 ) xi = xi % 2;
  142.                         else xi = 1;
  143.                     else xi = xi * 2;
  144.                 }
  145.             }
  146.         }
  147.         /* make the small window popup again */
  148.         shadowwin(small, shadow);
  149.         touchwin(small);
  150.         wrefresh(small);
  151.         /* and remove it */
  152.         wnoutrefresh(shadow);
  153.     }
  154.     randomize = !randomize;
  155.     /* trash the input that caused us to stop */
  156.     flushinp();
  157. }
  158.  
  159. message(str)
  160.  char *str;
  161. {
  162.     move(0,0);
  163.     clrtoeol();
  164.     standout();
  165.     printw("  %s  ", str);
  166.     standend();
  167.     refresh();
  168. }
  169.  
  170. /** the following two functions, help() and fillwin(), are general
  171.  *  purpose routines.  help displays a help window; fillwin fills
  172.  *  a window from a file, interpreting control characters as attributes.
  173.  *
  174.  *  Usage:
  175.  *    help(filename)
  176.  *      char *filename;
  177.  *    returns OK if successful, ERR otherwise.
  178.  *    In this version, the filename is only used the first time
  179.  *    through; subsequent calls just use the same data.
  180.  *    An error return is possible only on the first call, and
  181.  *    indicates a problem with the help file or a memory shortage.
  182.  *
  183.  *    The help window disappears when any key is pressed.
  184.  *
  185.  *    fillwin(f, win);
  186.  *     FILE *f; WINDOW *win;
  187.  *    returns 0 on EOF, 1 otherwise
  188.  *    Reads data until a formfeed, puts data into window.  Several
  189.  *    control characters are allowed; their occurrence in the file
  190.  *    causes fillwin to modify attributes.  The valid characters are:
  191.  *        ^B - bold
  192.  *        ^F - flash
  193.  *        ^N - normal
  194.  *        ^R - reverse
  195.  *        ^U - underline
  196.  */
  197.  
  198. help(file)
  199.  char *file;
  200. {
  201.  static WINDOW *helpwin = NULL, *shadow;
  202.  FILE *f;
  203.  
  204.     if( helpwin == NULL ) {
  205.         /* create help window */
  206.         helpwin = newwin(0,0,0,0);
  207.         shadow = newwin(0,0,0,0);
  208.         if( helpwin == NULL || shadow == NULL ) return(ERR);
  209.         leaveok(helpwin, TRUE);
  210.         keypad(helpwin, TRUE);
  211.         /* open up help file */
  212.         if( NULL == (f = fopen(file, "r")) ) return(ERR);
  213.         /* read help file into window */
  214.         fillwin(f, helpwin);
  215.         (void)fclose(f);
  216.     }
  217.     touchwin(helpwin);
  218.     shadowwin(helpwin, shadow);
  219.     wrefresh(helpwin);
  220.     (void)wgetch(helpwin);
  221.     wrefresh(shadow);
  222.     return(OK);
  223. }
  224.  
  225. /* fillwin - fill window with next paragraph from a file
  226.  *
  227.  *    returns 1 on success (or end of window), 0 if at end of file
  228.  *
  229.  *    if special control characters are found, they are
  230.  *    interpreted as attribute control:
  231.  *        ^B bold
  232.  *        ^F flashing
  233.  *        ^N normal
  234.  *        ^R reverse
  235.  *        ^U underline
  236.  */
  237. fillwin(f, win)
  238.  FILE *f; WINDOW *win;
  239. {
  240.  int ch;
  241.  int y,x;
  242.  
  243.      if( feof(f) ) return(0);
  244.      wmove(win, 0, 3);
  245.      while( EOF != (ch = getc(f)) ) {
  246.          /* break on formfeed */
  247.          if( ch == '\014' ) break;
  248.          switch(ch) {
  249.             case '\n':
  250.                 getyx(win, y, x);
  251.                 if( ERR == wmove(win, y+1, 3) )
  252.                     return(1);
  253.                 break;
  254.             case 2:        /* ^B */
  255.                 wattron(win, A_BOLD);
  256.                 break;
  257.             case 6:        /* ^F */
  258.                 wattron(win, A_BLINK);
  259.                 break;
  260.             case 14:    /* ^N */
  261.                 wattrset(win, 0);
  262.                 break;
  263.             case 18:    /* ^R */
  264.                 wattron(win, A_REVERSE);
  265.                 break;
  266.             case 21:    /* ^U */
  267.                 wattron(win, A_UNDERLINE);
  268.                 break;
  269.             default:
  270.                 if( ERR == waddch(win, ch) )
  271.                     return(1);
  272.                 break;
  273.         }
  274.     }
  275.     return(1);
  276. }
  277.